Faster Biclique Mining in Near-Bipartite Graphs

Abstract

Identifying dense bipartite subgraphs is a common graph data mining task. Many applications focus on the enumeration of all maximal bicliques (MBs), though sometimes the stricter variant of maximal induced bicliques (MIBs) is of interest. Recent work of Kloster et al. introduced a MIB-enumeration approach designed for “near-bipartite” graphs, where the runtime is parameterized by the size k of an odd cycle transversal (OCT), a vertex set whose deletion results in a bipartite graph. Their algorithm was shown to outperform the previously best known algorithm even when k was logarithmic in |V|. In this paper, we introduce two new algorithms optimized for near-bipartite graphs - one which enumerates MIBs in time $O(M_I |V| |E| k)$, and another based on the approach of Alexe et al. which enumerates MBs in time $O(M_B |V| |E| k)$, where $M_I$ and $M_B$ denote the number of MIBs and MBs in the graph, respectively. We implement all of our algorithms in open-source C++ code and experimentally verify that the OCT-based approaches are faster in practice than the previously existing algorithms on graphs with a wide variety of sizes, densities, and OCT decompositions.

This work was supported by the Gordon & Betty Moore Foundation’s Data-Driven Discovery Initiative under Grant GBMF4560 to Blair D. Sullivan and the NC State College of Engineering REU program.

Appendices

Appendices

A MIB-Enumeration Framework Subroutines

We now provide algorithmic details and proofs of the complexity and correctness of MakeIndMaximal and AddTo.

1.1 A.1 MakeIndMaximal

Recall that MakeIndMaximal takes in (C, S), where C is an induced biclique and $S \subseteq V$, and either returns a MIB $C^+$ where $C \subseteq C^+$, $C^+ \subseteq C \cup S$, $C \ne \emptyset$, or returns $\emptyset$. If it returns $\emptyset$ and $C \ne \emptyset$ then there is another MIB D which contains C and $v \in (V \setminus S) \setminus C$. We give pseudo-code of MakeIndMaximal in Algorithm 3.

Lemma 5

MakeIndMaximal returns a MIB $C^+$ where $C \subseteq C^+$, $C^+ \subseteq C \cup S$, $C \ne \emptyset$, or returns $\emptyset$.

Proof

Referring to the pseudo-code in Algorithm 3, it is clear that $C \subseteq C^+$, as no vertices are ever removed from the input biclique C. Furthermore, the only vertices added to $C^+$ are from S, so $C^+ \subseteq C \cup S$ and $C^+$ is the only biclique returned by MakeIndMaximal. Note that neither side of C is empty and the only vertices added are independent from the side of the biclique which they are added to, so if we do not return $\emptyset$ the object returned is an induced biclique. If no node from outside of S can be added to $C^+$, then we will not return $\emptyset$ and thus $C^+$ is maximal.

Lemma 6

If MakeIndMaximal returns $\emptyset$ and $C \ne \emptyset$ then there is another MIB D in G which contains C and $v \in (V \setminus S) \setminus C$.

Proof

Note that $C \subseteq C^* = C_1 \times C_2$ at line 12. As MakeIndMaximal returns $\emptyset$ there must be a vertex $v \in V_S = V \setminus (S \cup C^*)$ which can be added to $C^*$. Let D be a MIB containing $C^*$ and v, thus D suffices to prove the lemma.

Lemma 7

MakeIndMaximal runs in O(m) time.

Proof

Note that because G is connected, $n \in O(m)$. Setting $C_S$ and $V_S$ can be done in O(n) time. In each for loop, we can scan all of the edges incident to each v in the iterated-over set and keep count of how many nodes from $C_i$ have been seen (checking for inclusion can be done in O(1) time with an O(n) initialization step). Thus, each edge is scanned at most once per for loop.

1.2 A.2 AddTo

Recall that AddTo takes in (C, v) where $C=C_1 \times C_2$ is an induced biclique and $v \in V \setminus (C_1 \cup C_2)$, and returns the induced biclique where v is added to $C_1$, N(v) is removed from $C_1$, and $\overline{N}(v)$ is removed from $C_2$ if $C_2 \setminus \overline{N}(v) \ne \emptyset$ and $\emptyset$ otherwise. We give pseudo-code of AddTo in Algorithm 4.

Lemma 8

AddTo returns the induced biclique where v is added to $C_1$, N(v) is removed from $C_1$, and $\overline{N}(v)$ is removed from $C_2$ if $C_2 \setminus \overline{N}(v) \ne \emptyset$, and $\emptyset$ otherwise.

Proof

Referring to the pseudo-code in Algorithm 4, it is clear that v is added to $C_1$ and N(v) is removed from $C_1$. Additionally v’s non-neighbors are effectively removed from $C_2$ by intersecting it with N(v). If $C_2' = \emptyset$ then $C_2 \setminus \overline{N}(v) = \emptyset$ and $\emptyset$ is returned. Otherwise $C_1' \ne \emptyset$ since it includes v and thus $C_1' \times C_2'$ is a biclique. $C_1' \times C_2'$ must be an induced biclique as $C_2' \subseteq C_2$, $C_1' \setminus \{v\} \subseteq C_1$, and $C_1 \times C_2$ is an induced biclique and $(N(v) \cap C_1') = \emptyset$ by definition.

Lemma 9

AddTo runs in O(m) time.

Proof

Note that because G is connected, $n \in O(m)$. AddTo can be completed by scanning all of v’s O(m) incident edges in tandem with an O(n) preprocessing step to allow for constant-time look-ups when checking for inclusion in a set.

B MB-Enumeration Framework Subroutines

We give a detailed description of the MakeMaximal and Consensus subroutines used in OCT-MICA, along with arguments of their correctness and complexity.

1.1 B.1 MakeMaximal

Extending a biclique to be maximal is different in the non-induced case from the induced case, since MBs are completely characterized by one side of the biclique.

Lemma 10

MakeMaximal runs in O(m) time.

Proof

In order to form $X^*$, we can scan the edges incident to each $v \in Y$ and keep count of how many nodes from $X^*$ have been seen (checking for inclusion can be done in O(1) time with an O(n) initialization step). The same can be done for $Y^*$, where instead we scan the edges incident to each $v \in X^*$. Thus, each edge is scanned at most twice in MakeMaximal.

1.2 B.2 Consensus

The MICA section of OCT-MICA relies heavily on the Consensus operation introduced in [3] for finding new candidate bicliques. For each pair of bicliques, there are four candidate bicliques which form the consensus of the pair. Note that any of the four candidates may be empty and if so discarded. Consensus runs in O(n) time using standard techniques for set union and intersection.

C Additional Enumeration Experiments

Here we include figures corresponding to additional experimental results of our initial benchmarking and on the computation biology data from [29] described in Sects. 5.2 and 5.4 respectively (Figs. 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 and Tables 2, 3).

Fig. 5.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 10$. The ratio $n_L/n_R$ was varied.

Fig. 6.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$ and $n_O = 10$. The ratio $n_L/n_R$ was varied.

Fig. 7.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 19 \approx 3\log _3(n_B)$. The ratio $n_L/n_R$ was varied.

Fig. 8.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$ and $n_O = 14 \approx 3\log _3(n_B)$. The ratio $n_L/n_R$ was varied.

Fig. 9.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 10$. The coefficient of variation between L and R was varied.

Fig. 10.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$ and $n_O = 10$. The coefficient of variation between L and R was varied.

Fig. 11.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 19 \approx 3\log _3(n_B)$. The coefficient of variation between L and R was varied.

Fig. 12.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$ and $n_O = 14 \approx 3\log _3(n_B)$. The coefficient of variation between L and R was varied.

Fig. 13.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O$ was varied.

Fig. 14.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 19 \approx 3\log _3(n_B)$. The expected edge density between O and $\{L,R\}$ was varied.

Fig. 15.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 10$. The expected edge density within O was varied.

Fig. 16.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 1000$ and $n_O = 19 \approx 3\log _3(n_B)$. The expected edge density within O was varied.

Fig. 17.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 150$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied except for the expected edge density within O which was fixed to 0.05.

Fig. 18.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 150$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied, including the expected edge density within O.

Fig. 19.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied except for the expected edge density within O which was fixed to 0.05.

Fig. 20.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 200$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied, including the expected edge density within O.

Fig. 21.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 300$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied except for the expected edge density within O which was fixed to 0.05.

Fig. 22.

Runtimes of the MIB-enumerating (left) and MB-enumerating (right) algorithms on graphs where $n_B = 300$, $n_L = n_R$ and $n_O = 5$. The expected edge density in the graph was varied, including the expected edge density within O.

Table 2. The runtimes (rounded to nearest thousandth-of-a-second) of the biclique-enumeration algorithms on the Afro-American subset of the Wernicke-Hüffner computational biology data [29].

Table 3. The runtimes (rounded to nearest thousandth-of-a-second) of the biclique-enumeration algorithms on the Japanese subset of the Wernicke-Hüffner computational biology data [29].